home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / amiga / hdf / hdf.lha / DFR8.C < prev    next >
Encoding:
C/C++ Source or Header  |  1980-02-06  |  30.2 KB  |  874 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.10r3
  4. *                Dec 6, 1990
  5. *
  6. * NCSA HDF Version 3.10r3 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. #ifdef RCSID
  23. static char RcsId[] = "@(#)$Revision: 3.4 $";
  24. #endif
  25. /*
  26. $Header: /pita/work/HDF/dev/RCS/src/dfr8.c,v 3.4 90/07/02 10:12:00 clow beta $
  27.  
  28. $Log:    dfr8.c,v $
  29.  * Revision 3.4  90/07/02  10:12:00  clow
  30.  * some cosmetic modifications
  31.  * 
  32. */
  33. /*-----------------------------------------------------------------------------
  34.  * File:    dfr8.c
  35.  * Purpose: read and write 8-bit Raster Image Groups
  36.  * Invokes: df.c, dfcomp.c, dfgroup.c, dfrig.h
  37.  * Contents: 
  38.  *  DFR8getdims: retrieve information about 8-bit image dimensions
  39.  *  DFR8getimage: retrieve 8-bit image and associated palette
  40.  *  DFR8setpalette: specify palette to be used with subsequent 8-bit images
  41.  *  DFR8Iputimage: internal routine that write 8-bit images to files
  42.  *  DFR8putimage: write 8-bit image into an HDF file
  43.  *  DFR8addimage: append another 8-bit image to an HDF file
  44.  *  DFR8getrig: read in a raster image group for 8-bit images
  45.  *  DFR8putrig: write out a raster image group for 8-bit images
  46.  *  DFR8nimages: number of images in HDF file
  47.  *  DFR8readref: get image with this reference number next
  48.  *  DFR8writeref: put image with this reference number next
  49.  *  DFR8restart: forget info about last file accessed - restart from beginning
  50.  *  DFR8lastref: return reference number of last element read or written
  51.  *  DFR8Iopen: open/reopen file
  52.  *  DFR8Iriginfo: obtain info about next RIG/RI8 to get
  53.  * Remarks: A RIG specifies attributes associated with an image - palette, 
  54.  *          dimension, compression, color compensation etc.
  55.  *          The palette for an 8-bit image is assumed to always be 768 bytes
  56.  *          The palette is arranged as RGBRGB...
  57.  *---------------------------------------------------------------------------*/
  58.  
  59.  
  60. #include "df.h"
  61.  
  62. static int foundRig = -1;    /* -1: don't know if HDF file has RIGs */
  63.                 /* 0: No RIGs, try for RI8s etc. */
  64.                 /* 1: RIGs used, ignore RI8s etc. */
  65. static DFRrig Readrig;        /* information about RIG being read */
  66. static DFRrig Writerig;        /* information about RIG being written */
  67. static int Newdata = 0;        /* does Readrig contain fresh data? */
  68. static uint16 Writeref=0;    /* ref of next image to put in this file */
  69. static int Newpalette=(-1);    /* -1 = no palette is associated */
  70.                 /* 0 = palette already written out */
  71.                 /* 1 = new palette, not yet written out */
  72. static char Palette[768];    /* to store palette for 8-bit images */
  73. static uint16 Refset=0;        /* Ref of image to get next */
  74. static uint16 Lastref = 0;    /* Last ref read/written */
  75. static DFRrig Zrig = {        /* empty RIG for initialization */
  76.     {0, 0}, {0, 0, 0, 0, 0, 0, 0, 0},
  77.     {0, 0}, {0, 0, 0, 0, 0, 0, 0, 0},
  78.     {0, 0}, {0, 0, 0, 0, 0, 0, 0, 0},
  79.     0, 0, 0.0, 0.0, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0},
  80.     {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, NULL
  81. };
  82.  
  83. #ifndef VMS
  84. DF *DFR8Iopen();
  85. #else /*VMS*/
  86. DF *_DFR8Iopen();
  87. #endif
  88.  
  89. typedef struct R8dim {
  90.     uint16 xd;
  91.     uint16 yd;
  92. } R8dim;            /* dimensions of raster-8 image */
  93.  
  94.  
  95. /*-----------------------------------------------------------------------------
  96.  * Name:    DFR8getdims
  97.  * Purpose: get dimensions of next image from RIG, also if there is a palette
  98.  * Inputs:  filename: name of HDF file
  99.  *          pxdim, pxdim, pointer to locations for returning x,y dimensions
  100.  *          pispal: pointer to location for rtning whether there is a palette
  101.  * Returns: 0 on success, -1 on failure with DFerror set
  102.  *          *pxdim, *pydim are set to dimensions of the next image
  103.  *          *pispal is set to 1 if a palette is associated with it, else 0
  104.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  105.  * Invokes: DFR8Iopen, DFclose, DFR8Iriginfo, DFIerr
  106.  * Remarks: will also handle file with just raster-8 tags: RI8, CI8, ID8, IP8
  107.  *---------------------------------------------------------------------------*/
  108.  
  109. int DFR8getdims(filename, pxdim, pydim, pispal)
  110. char *filename;
  111. int32 *pxdim, *pydim;
  112. int *pispal;
  113. {
  114.     DF *dfile;
  115.  
  116.     DFerror = DFE_NOERROR;
  117.  
  118.     if (!pxdim || !pydim) {    /* check for zero dimensions */
  119.         DFerror = DFE_BADPTR;
  120.         return(-1);
  121.     }
  122.  
  123.     dfile = DFR8Iopen(filename, DFACC_READ);
  124.     if (dfile == NULL) return(-1);
  125.  
  126.     if (DFR8Iriginfo(dfile)<0)    /* reads next RIG or RI8 from file */
  127.         return(DFIerr(dfile));    /* on error, close file and return -1 */
  128.  
  129.     Newdata = 1;
  130.     *pxdim = Readrig.descimage.xdim;
  131.     *pydim = Readrig.descimage.ydim;
  132.     if (pispal) *pispal = Readrig.lut.tag ? 1 : 0; /* is there a palette */
  133.  
  134.     return(DFclose(dfile));
  135. }
  136.  
  137. /*-----------------------------------------------------------------------------
  138.  * Name:    DFR8getimage
  139.  * Purpose: get next image from a RIG, get palette also if desired
  140.  * Inputs:  filename: name of HDF file
  141.  *          image: space to read image into
  142.  *          xdim, ydim: dimensions of space allocated by user for image
  143.  *          pal: 768-byte space for palette, null if palette not wanted
  144.  * Returns: 0 on success, -1 on failure with DFerror set
  145.  *          image in image, palette in pal
  146.  * Users:   HDF HLL users, utilities, other routines
  147.  * Invokes: DFR8Iopen, DFR8Iriginfo, DFIerr, DFclose, DFgetelement, DFgetcomp
  148.  * Remarks: Will also get RI8s and CI8s if no RIGs in file
  149.  *          Normally,DFR8getdims is called first and it finds next image to get
  150.  *          But if that is not called, DFR8getimage will itself find next image
  151.  *          Automatically decompresses images
  152.  *---------------------------------------------------------------------------*/
  153.  
  154. int DFR8getimage(filename, image, xdim, ydim, pal)
  155. char *filename;
  156. int32 xdim, ydim;
  157. char *image;
  158. char *pal;
  159. {
  160.     DF *dfile;
  161.  
  162.     DFerror = DFE_NOERROR;
  163.  
  164.     if ((xdim<=0) || (ydim<=0)) {
  165.         DFerror = DFE_BADDIM;
  166.         return(-1);
  167.     }
  168.  
  169.     dfile = DFR8Iopen(filename, DFACC_READ);
  170.     if (dfile == NULL) return(-1);
  171.  
  172.     if (!Newdata) {        /* if Readrig not fresh */
  173.         if (DFR8Iriginfo(dfile)<0) /* reads next RIG or RI8 from file */
  174.             return(DFIerr(dfile)); /* on error, close file and return -1 */
  175.     }
  176.     Newdata = 0;        /* read new RIG next time */
  177.  
  178.     if ((Readrig.descimage.xdim > xdim) || (Readrig.descimage.ydim > ydim)) {
  179.         DFerror = DFE_NOTENOUGH; /* not enough space */
  180.         return(DFIerr(dfile));
  181.     }
  182.  
  183.     /* read image */
  184.     if (Readrig.descimage.compr.tag) { /* compressed image */
  185.         if (DFgetcomp(dfile, Readrig.image.tag, Readrig.image.ref, image,
  186.               Readrig.descimage.xdim, Readrig.descimage.ydim,
  187.               Readrig.descimage.compr.tag)<0)
  188.             return(DFIerr(dfile));
  189.     } else {            /* non-compressed raster image */
  190.         if (DFgetelement(dfile, Readrig.image.tag, Readrig.image.ref, image)<0)
  191.             return(DFIerr(dfile));
  192.     }
  193.     if (xdim > Readrig.descimage.xdim) {
  194.     int off1, off2;
  195.     int x, y;
  196.     off1 = (Readrig.descimage.ydim - 1) * xdim;
  197.     off2 = (Readrig.descimage.ydim - 1) * Readrig.descimage.xdim;
  198.     for (y = Readrig.descimage.ydim - 1; y > 0; y-- ) {
  199.         for (x = Readrig.descimage.xdim - 1; x >= 0; x--)
  200.         image[off1+x] = image[off2+x];
  201.         off1 -= xdim;
  202.         off2 -= Readrig.descimage.xdim;
  203.     }
  204.     }
  205.  
  206.     if (pal && Readrig.lut.tag) { /* read palette */
  207.         if (DFgetelement(dfile, Readrig.lut.tag, Readrig.lut.ref, pal)<0)
  208.             return(DFIerr(dfile));
  209.     }
  210.     return(DFclose(dfile));
  211. }
  212.  
  213. /*-----------------------------------------------------------------------------
  214.  * Name:    DFR8setpalette
  215.  * Purpose: set palette for subsequent images
  216.  * Inputs:  pal: palette to set
  217.  * Returns: 0 on success, -1 on failure with DFerror set
  218.  * Users:   HDF users, utilities, other routines
  219.  * Invokes: none
  220.  * Remarks: if pal is NULL, no palette is associated with subsequent images
  221.  *---------------------------------------------------------------------------*/
  222.  
  223. int DFR8setpalette(pal)
  224. char *pal;
  225. {
  226.     int i;
  227.  
  228.     DFerror = DFE_NOERROR;
  229.  
  230.     if (!pal) {
  231.         Newpalette = -1;    /* no palette */
  232.         Writerig.lut.tag = 0;
  233.         Writerig.lut.ref = 0;   /* forget tag/ref of previous palette */
  234.         Writerig.desclut.xdim = 0;
  235.         Writerig.desclut.ncomponents = 0;
  236.     } else {            /* store palette */
  237.         for (i=0; i<768; i++)
  238.             Palette[i] = pal[i];
  239.         Newpalette = 1;
  240.     }
  241.     return(0);
  242. }
  243.  
  244. /*-----------------------------------------------------------------------------
  245.  * Name:    DFR8Iputimage
  246.  * Purpose: Internal routine to write RIG to file
  247.  * Inputs:  filename: name of HDF file
  248.  *          image: image to be written to file
  249.  *          xdim, ydim: dimensions of image
  250.  *          compress: compression scheme to be used on image, 0 if none
  251.  *                    possible values are DFTAG_RLE and DFTAG_IMC
  252.  *          op: 0 will overwrite existing file, 1 will append image to file
  253.  * Returns: 0 on success, -1 on failure with DFerror set
  254.  * Users:   HDF systems programmers, DFR8putimage, DFR8addimage
  255.  * Invokes: DFR8Iopen, DFclose, DFputelement, DFdup, DFR8putrig, DFputcomp,
  256.  *          DFIerr
  257.  * Remarks: Palette will be associated with image is isPalette is 1
  258.  *          Palette will be written to file if not written before (Palref=0)
  259.  *          Creates both RIG and RI8/CI8 tags, to accomodate older programs
  260.  *---------------------------------------------------------------------------*/
  261.  
  262. int DFR8Iputimage(filename, image, xdim, ydim, compress, op)
  263. char *filename;
  264. int32 xdim, ydim;
  265. char *image;
  266. int compress;               /* compression scheme */
  267. int op;                     /* 0 is a put, 1 is a putnext */
  268. {
  269.     int access;             /* create if op 0, write if op 1 */
  270.     DF *dfile;
  271.     uint16 r8tag;           /* RIG and raster tags of image being written */
  272.     char *pal;     /* pointer to palette to be written */
  273.     char newpal[768];  /* Imcomp creates new palette to be associated*/
  274.     int wdim;               /* have dimensions already been written out? */
  275.  
  276.     DFerror = DFE_NOERROR;
  277.  
  278.     if ((xdim<=0) || (ydim<=0)) {
  279.         DFerror = DFE_BADDIM;
  280.         return(-1);
  281.     }
  282.     if (!image) {
  283.         DFerror = DFE_BADPTR;
  284.         return(-1);
  285.     }
  286.     pal = (Newpalette>=0) ? Palette : NULL;
  287.     access = op ? DFACC_WRITE : DFACC_CREATE;
  288.  
  289.     dfile = DFR8Iopen(filename, access);
  290.     if (dfile==NULL) return(-1);
  291.  
  292.     if (!Writeref) Writeref = DFnewref(dfile);
  293.     if (!Writeref) return(-1);
  294.  
  295.     /* write out image */
  296.     if (compress) {
  297.         if (DFputcomp(dfile, DFTAG_CI, Writeref, image, xdim, ydim,
  298.               pal, newpal, compress)<0)
  299.             return(DFIerr(dfile));
  300.         Writerig.image.tag = DFTAG_CI;
  301.         if (compress==DFTAG_IMC) {
  302.             pal = newpal;    /* Imcomp creates new pal */
  303.             Newpalette = 1;    /* write out palette */
  304.         }
  305.     } else {            /* image need not be compressed */
  306.         if (DFputelement(dfile, DFTAG_RI, Writeref, image, xdim*ydim)<0)
  307.             return(DFIerr(dfile));
  308.         Writerig.image.tag = DFTAG_RI;
  309.     }
  310.     Writerig.image.ref = Writeref;
  311.     Writerig.descimage.ncomponents = 1;
  312.     Writerig.aspectratio = 1.0;
  313.  
  314.     /* Write out Raster-8 tags for those who want it */
  315.     r8tag = compress ?
  316.     ((compress==DFTAG_RLE) ? DFTAG_CI8 : DFTAG_II8) : DFTAG_RI8;
  317.     if (DFdup(dfile, r8tag, Writeref, Writerig.image.tag, Writeref)<0)
  318.         return(DFIerr(dfile));
  319.  
  320.     /* Write out palette */
  321.     if (pal) {            /* if there is a palette */
  322.         if (Newpalette==1) {    /* write palette */
  323.             if (DFputelement(dfile, DFTAG_LUT, Writeref, pal, (int32) 768)<0)
  324.                 return(DFIerr(dfile));
  325.             Writerig.lut.tag = DFTAG_LUT;
  326.             Writerig.lut.ref = Writeref;
  327.             Writerig.desclut.xdim = 768;
  328.             Writerig.desclut.ncomponents = 1;
  329.         }
  330.         if (compress!=DFTAG_IMC) Newpalette = 0;
  331.     /* if IMCOMP, original palette not written out */
  332.  
  333.     /* put in Raster-8 stuff also, for those who want it */
  334.         if (DFdup(dfile, DFTAG_IP8, Writeref, Writerig.lut.tag,
  335.           Writerig.lut.ref)<0)
  336.             return(DFIerr(dfile));
  337.     }
  338.  
  339.     /* Write out RIG */
  340.     if ((Writerig.descimage.xdim==xdim) && (Writerig.descimage.ydim==ydim) &&
  341.     (Writerig.descimage.compr.tag==compress))
  342.         wdim = 0;
  343.     else {
  344.         wdim = 1;
  345.         Writerig.descimage.xdim = xdim;
  346.         Writerig.descimage.ydim = ydim;
  347.         Writerig.descimage.compr.tag = compress;
  348.     }
  349.     if (DFR8putrig(dfile, Writeref, &Writerig, wdim)<0) /* writes ID, NT */
  350.         return(DFIerr(dfile));
  351.  
  352.     Lastref = Writeref;        /* remember ref written */
  353.  
  354.     Writeref = 0;               /* don't know ref to write next */
  355.  
  356.     return(DFclose(dfile));
  357. }
  358.  
  359. /*-----------------------------------------------------------------------------
  360.  * Name:    DFR8putimage
  361.  * Purpose: Write RIG to HDF file
  362.  * Inputs:  filename: name of HDF file
  363.  *          image: image to be written to file
  364.  *          xdim, ydim: dimensions of image
  365.  *          compress: compression scheme to be used on image, 0 if none
  366.  * Returns: 0 on success, -1 on failure with DFerror set
  367.  * Users:   HDF HLL users, utilities, other routines
  368.  * Invokes: DFR8Iputimage
  369.  * Remarks: overwrites existing HDF file
  370.  *---------------------------------------------------------------------------*/
  371.  
  372. int DFR8putimage(filename, image, xdim, ydim, compress)
  373. char *filename;
  374. int32 xdim, ydim;
  375. char *image;
  376. int compress;
  377. {
  378.     return(DFR8Iputimage(filename, image, xdim, ydim, compress, 0));
  379. }
  380.  
  381.  
  382. /*-----------------------------------------------------------------------------
  383.  * Name:    DFR8addimage
  384.  * Purpose: Append RIG to HDF file
  385.  * Inputs:  filename: name of HDF file
  386.  *          image: image to be written to file
  387.  *          xdim, ydim: dimensions of image
  388.  *          compress: compression scheme to be used on image, 0 if none
  389.  * Returns: 0 on success, -1 on failure with DFerror set
  390.  * Users:   HDF HLL users, utilities, other routines
  391.  * Invokes: DFR8Iputimage
  392.  * Remarks: inserts image into existing file, will create file if necessary
  393.  *---------------------------------------------------------------------------*/
  394.  
  395. int DFR8addimage(filename, image, xdim, ydim, compress)
  396. char *filename;
  397. int32 xdim, ydim;
  398. char *image;
  399. int compress;
  400. {
  401.     return(DFR8Iputimage(filename, image, xdim, ydim, compress, 1));
  402. }
  403.  
  404.  
  405. /*****************************************************************************/
  406. /* This is the next lower layer - procedures to get and put a RIG. */
  407. /* These are specific to 8-bit */
  408. /*****************************************************************************/
  409.  
  410. /*-----------------------------------------------------------------------------
  411.  * Name:    DFR8getrig
  412.  * Purpose: Read a RIG into memory
  413.  * Inputs:  dfile: pointer to HDF file containing RIG
  414.  *          ref: reference number of RIG to get
  415.  *          rig: struct in which to place info obtained
  416.  * Returns: 0 on success, -1 on failure with DFerror set
  417.  *          contents of RIG in the struct rig
  418.  * Users:   HDF programmers, utilities, DFR8getdims,DFR8getimage
  419.  * Invokes: DFdiget, DFdinext, DFIcheck, DFgetelement
  420.  * Remarks: assumes 8-bit
  421.  *---------------------------------------------------------------------------*/
  422.  
  423. int DFR8getrig(dfile, ref, rig)
  424. DF *dfile;
  425. uint16 ref;
  426. DFRrig *rig;
  427. {
  428.     DFdi elmt;
  429.     char ntstring[4];
  430.  
  431.     DFerror = DFE_NOERROR;
  432.  
  433.     if (DFIcheck(dfile))
  434.         return( -1);
  435.     if (!ref) {
  436.         DFerror = DFE_BADREF;
  437.         return(-1);
  438.     }
  439.  
  440.     if (DFdiread(dfile, DFTAG_RIG, ref)<0) /* read RIG into memory */
  441.         return(-1);
  442.  
  443.     *rig = Zrig;        /* fill rig with zeroes */
  444.     while (!DFdiget(&elmt)) {    /* get next tag/ref from RIG */
  445.         switch (elmt.tag) {    /* process tag/ref */
  446.             case DFTAG_CI:
  447.             case DFTAG_RI:
  448.                 rig->image.tag = elmt.tag; /* put tag/ref in struct */
  449.                 rig->image.ref = elmt.ref;
  450.                 break;
  451.             case DFTAG_LUT:
  452.                 rig->lut.tag = elmt.tag;
  453.                 rig->lut.ref = elmt.ref;
  454.                 break;
  455.             case DFTAG_ID:    /* read description info */
  456. #ifdef DF_STRUCTOK
  457.                 if (DFgetelement(dfile, elmt.tag, elmt.ref, &rig->descimage)<0)
  458.                     return(-1);
  459. #else /*DF_STRUCTOK*/
  460.                 if (DFgetelement(dfile, elmt.tag, elmt.ref, DFtbuf)>0) {
  461.                     register char *p;
  462.                     p = DFtbuf;
  463.                     INT32READ(p, rig->descimage.xdim);
  464.                     INT32READ(p, rig->descimage.ydim);
  465.                     UINT16READ(p, rig->descimage.nt.tag);
  466.                     UINT16READ(p, rig->descimage.nt.ref);
  467.                     INT16READ(p, rig->descimage.ncomponents);
  468.                     INT16READ(p, rig->descimage.interlace);
  469.                     UINT16READ(p, rig->descimage.compr.tag);
  470.                     UINT16READ(p, rig->descimage.compr.ref);
  471.                 } else
  472.                     return(-1);
  473. #endif /*DF_STRUCTOK*/
  474.                 if (rig->descimage.ncomponents!=1) {
  475.                     DFerror = DFE_BADCALL;
  476.                     return(-1);
  477.                 }
  478.                 if (rig->descimage.nt.tag==0) break; /* old RIGs */
  479.  
  480.         /* read NT */
  481.                 if (DFgetelement(dfile, rig->descimage.nt.tag,
  482.                  rig->descimage.nt.ref, ntstring)<0)
  483.                     return(-1);
  484.                 if ((ntstring[2]!=8) || (ntstring[1]!=DFNT_UCHAR)) {
  485.                     DFerror = DFE_BADCALL;
  486.                     return(-1);
  487.                 }
  488.                 break;
  489.             default:        /* ignore unknown tags */
  490.                 break;
  491.         }
  492.     }
  493.     return(0);
  494. }
  495.  
  496. /*-----------------------------------------------------------------------------
  497.  * Name:    DFR8putrig
  498.  * Purpose: Write RIG struct out to HDF file
  499.  * Inputs:  dfile: HDF file pointer
  500.  *          ref: ref to put RIG with
  501.  *          rig: struct containing RIG info to put
  502.  *          wdim: if 1, write out new description records. if 0 already written
  503.  * Returns: 0 on success, -1 on failure with DFerror set
  504.  * Users:   HDF programmers, utilities, DFR8Iputimage, other routines
  505.  * Invokes: DFIcheck, DFdistart, DFdiadd, DFdiend, DFputelement
  506.  * Remarks: assumes 8-bit.  Writes out NT if necessary, ID, ID8 if told to
  507.  *---------------------------------------------------------------------------*/
  508.  
  509. int DFR8putrig(dfile, ref, rig, wdim)
  510. DF *dfile;
  511. uint16 ref;
  512. DFRrig *rig;
  513. int wdim;
  514. {
  515.     static uint16 prevdimref=0; /*ref of previous dimension record, to reuse */
  516.     R8dim im8dim;
  517.     char ntstring[4];
  518.  
  519.     DFerror = DFE_NOERROR;
  520.  
  521.     if (DFIcheck(dfile))
  522.         return( -1);
  523.     if (!ref) {
  524.         DFerror = DFE_BADREF;
  525.         return(-1);
  526.     }
  527.  
  528.     if (!rig->descimage.nt.tag) {
  529.     /* construct and write out NT */
  530.         ntstring[0] = DFNT_VERSION; /* version */
  531.         ntstring[1] = DFNT_UCHAR; /* type */
  532.         ntstring[2] = 8;    /* width: RIG data is 8-bit chars */
  533.         ntstring[3] = DFNTC_BYTE; /* class: data are numeric values */
  534.         if (DFputelement(dfile, DFTAG_NT, ref, ntstring, (int32) 4) <0)
  535.             return(-1);
  536.         rig->descimage.nt.tag = DFTAG_NT;
  537.         rig->descimage.nt.ref = ref;
  538.     }
  539.         
  540.     im8dim.xd = rig->descimage.xdim;
  541.     im8dim.yd = rig->descimage.ydim;
  542.     if (wdim) {
  543. #ifdef DF_STRUCTOK        /* write out description record */
  544.         if (DFputelement(dfile, DFTAG_ID8, ref, &im8dim, (int32) 4)<0) /*ID8 */
  545.             return(-1);
  546.         if (DFputelement(dfile, DFTAG_ID, ref, &rig->descimage,    /* ID */
  547.              sizeof(rig->descimage))<0)
  548.             return(-1);
  549. #else /*DF_STRUCTOK*/
  550.         register char *p;
  551.         p = DFtbuf;
  552.         INT32WRITE(p, rig->descimage.xdim);
  553.         INT32WRITE(p, rig->descimage.ydim);
  554.         UINT16WRITE(p, rig->descimage.nt.tag);
  555.         UINT16WRITE(p, rig->descimage.nt.ref);
  556.         INT16WRITE(p, rig->descimage.ncomponents);
  557.         INT16WRITE(p, rig->descimage.interlace);
  558.         UINT16WRITE(p, rig->descimage.compr.tag);
  559.         UINT16WRITE(p, rig->descimage.compr.ref);
  560.         if (DFputelement(dfile, DFTAG_ID, ref, DFtbuf,(int32)(p-DFtbuf))<0)
  561.             return(-1);
  562.     /* write out ID8 */
  563.         p = DFtbuf;
  564.         UINT16WRITE(p, im8dim.xd);
  565.         UINT16WRITE(p, im8dim.yd);
  566.         if (DFputelement(dfile, DFTAG_ID8, ref, DFtbuf, (int32) 4)<0)
  567.             return(-1);
  568. #endif /*DF_STRUCTOK*/
  569.         prevdimref = ref;
  570.     }
  571.     if (!prevdimref) {
  572.         DFerror = DFE_BADDIM;
  573.         return(-1);
  574.     }
  575.  
  576.     /* prepare to start writing rig */
  577.     /* ### NOTE: the second parameter to this call may go away */
  578.     if (DFdisetup(10)<0) return(-1); /* max 10 tag/refs in set */
  579.  
  580.     /* add tag/ref to RIG - image description, image and palette */
  581.     if (DFdiput(DFTAG_ID, prevdimref) < 0) return(-1);
  582.  
  583.     if (DFdiput(rig->image.tag, rig->image.ref) < 0) return(-1);
  584.  
  585.     if (rig->lut.ref)
  586.         if (DFdiput(rig->lut.tag, rig->lut.ref) < 0) return(-1);
  587.  
  588.         /* write out RIG */
  589.     return(DFdiwrite(dfile, DFTAG_RIG, ref));
  590. }
  591.  
  592.  
  593. /*-----------------------------------------------------------------------------
  594.  * Name:    DFR8nimages
  595.  * Purpose: How many images are present in this file?
  596.  * Inputs:  filename: name of HDF file
  597.  * Returns: number of images  on success, -1 on failure with DFerror set
  598.  * Users:   HDF programmers, other routines and utilities
  599.  * Invokes: DFR8Iopen, DFclose, DFnumber
  600.  * Remarks: the number is the number of RIGs if RIGs are present
  601.  *          If not, it is the number of RI8s + number of CI8s
  602.  *---------------------------------------------------------------------------*/
  603.  
  604. int DFR8nimages(filename)
  605. char *filename;
  606. {
  607.     DF *dfile;
  608.     int nimages=0;
  609.  
  610.     DFerror = DFE_NOERROR;
  611.  
  612.     /* should use reopen if same file as last time - more efficient */
  613.     dfile = DFR8Iopen(filename, DFACC_READ);
  614.     if (dfile==NULL) return(-1);
  615.  
  616.     /* find next rig */
  617.     if (foundRig) {        /* either RIGs present or don't know */
  618.         nimages = DFnumber(dfile, DFTAG_RIG); /* count number of RIGs */
  619.         if (nimages>0) {
  620.             foundRig = 1;
  621.             if (DFclose(dfile)<0) return(-1);
  622.             return(nimages);
  623.         }
  624.         foundRig = 0;
  625.     }
  626.     nimages = DFnumber(dfile, DFTAG_RI8);
  627.     nimages += DFnumber(dfile, DFTAG_CI8);
  628.     if (DFclose(dfile)<0) return(-1);
  629.     return(nimages);
  630. }
  631.  
  632. /*-----------------------------------------------------------------------------
  633.  * Name:    DFR8readref
  634.  * Purpose: Set ref of image to get next
  635.  * Inputs:  filename: file to which this applies
  636.  *          ref: reference number of next get
  637.  * Returns: 0 on success, -1 on failure
  638.  * Users:   HDF programmers, other routines and utilities
  639.  * Invokes: DFR8Iopen, DFIfind
  640.  * Remarks: checks if image with this ref exists
  641.  *---------------------------------------------------------------------------*/
  642.  
  643. int DFR8readref(filename, ref)
  644. char *filename;
  645. uint16 ref;
  646. {
  647.     DF *dfile;
  648.     int cdd;
  649.     DFdle *dlep;
  650.  
  651.     DFerror = DFE_NOERROR;
  652.  
  653.     dfile = DFR8Iopen(filename, DFACC_READ);
  654.     if (dfile==NULL) return(-1);
  655.     if (DFIfind(dfile, DFTAG_RIG, ref, 1, 0, 0, &dlep, &cdd)<0)
  656.         if (DFIfind(dfile, DFTAG_RI8, ref, 1, 0, 0, &dlep, &cdd)<0)
  657.             if (DFIfind(dfile, DFTAG_CI8, ref, 1, 0, 0, &dlep, &cdd)<0)
  658.                 return(DFIerr(dfile));
  659.     Refset = ref;
  660.     Newdata = 0;
  661.     return(DFclose(dfile));
  662. }
  663.  
  664. /*-----------------------------------------------------------------------------
  665.  * Name:    DFR8writeref
  666.  * Purpose: Set ref of image to put next
  667.  * Inputs:  filename: file to which this applies
  668.  *          ref: reference number of next put
  669.  * Returns: 0 on success, -1 on failure
  670.  * Users:   HDF programmers, other routines and utilities
  671.  * Invokes: DFR8Iopen, DFIfind
  672.  * Remarks: none
  673.  *---------------------------------------------------------------------------*/
  674.  
  675. /* shut lint up */
  676. /* ARGSUSED */
  677. int DFR8writeref(filename, ref)
  678. char *filename;
  679. uint16 ref;
  680. {
  681.     DFerror = DFE_NOERROR;
  682.  
  683.     Writeref = ref;
  684.     return(0);
  685. }
  686.  
  687. static char Lastfile[DF_MAXFNLEN];          /* last file opened */
  688.  
  689. /*-----------------------------------------------------------------------------
  690.  * Name:    DFR8restart
  691.  * Purpose: Do not remember info about file - get again from first image
  692.  * Inputs:  none
  693.  * Returns: 0 on success
  694.  * Users:   HDF programmers
  695.  * Remarks: Just reset Lastfile to NULL
  696.  *---------------------------------------------------------------------------*/
  697.  
  698. int DFR8restart()
  699. {
  700.     Lastfile[0] = '\0';
  701.     return(0);
  702. }
  703.  
  704.  
  705. /*-----------------------------------------------------------------------------
  706.  * Name:    DFR8lastref
  707.  * Purpose: Return last ref written or read
  708.  * Inputs:  none
  709.  * Globals: Lastref
  710.  * Returns: ref on success, -1 on error with DFerror set
  711.  * Users:   HDF users, utilities, other routines
  712.  * Invokes: none
  713.  * Method:  return Lastref
  714.  * Remarks: none
  715.  *---------------------------------------------------------------------------*/
  716.  
  717. int DFR8lastref()
  718. {
  719.     return((int) Lastref);
  720. }
  721.  
  722.  
  723.  
  724. /******************************************************************************/
  725. /*----------------------- Internal routines ---------------------------------*/
  726. /******************************************************************************/
  727.  
  728.  
  729. /*-----------------------------------------------------------------------------
  730.  * Name:    DFR8Iopen
  731.  * Purpose: open or reopen a file
  732.  * Inputs:  filename: name of file to open
  733.  *          access : access mode
  734.  * Returns: file pointer on success, NULL on failure with DFerror set
  735.  * Users:   HDF systems programmers, all the RIG routines 
  736.  * Invokes: DFopen
  737.  * Remarks: This is a hook for someday providing more efficient ways to
  738.  *          reopen a file, to avoid re-reading all the headers
  739.  *---------------------------------------------------------------------------*/
  740.  
  741. DF *DFR8Iopen(filename, access)
  742. char *filename;
  743. int access;
  744. {
  745.  
  746.     DF *dfile;
  747.  
  748.     /* use reopen if same file as last time - more efficient */
  749.     if (strncmp(Lastfile,filename,DF_MAXFNLEN) || (access==DFACC_CREATE)) {
  750.                 /* treat create as different file */
  751.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  752.         foundRig = -1;        /* don't know if any RIGs in file */
  753.         Refset = 0;        /* no ref to get set for this file */
  754.         Newdata = 0;
  755.         Readrig = Zrig;        /* blank out read/write RIGs */
  756.         Writerig = Zrig;
  757.         if (Newpalette!=(-1)) Newpalette = 1; /* need to write out palette */
  758.     } else
  759.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  760.  
  761.     strncpy(Lastfile, filename, DF_MAXFNLEN);
  762.     /* remember filename, so reopen may be used next time if same file */
  763.     return(dfile);
  764. }
  765.  
  766. /*-----------------------------------------------------------------------------
  767.  * Name:    DFR8Iriginfo
  768.  * Purpose: Getinformation about next RIG or Raster-8 in file
  769.  * Inputs:  dfile: pointer to DF file
  770.  * Returns: 0 on success, -1 on failure with DFerror set
  771.  * Users:   HDF systems programmers
  772.  * Invokes: DFIfind, DFgetelement
  773.  * Remarks: checks for RIGs first, then RI8s
  774.  *          if Refset set, gets image with that ref, if any
  775.  *---------------------------------------------------------------------------*/
  776.  
  777. int DFR8Iriginfo(dfile)
  778. DF *dfile;
  779. {
  780.     DFdle *dlep;
  781.     int cdd;
  782.     uint16 riref=0, ciref=0;
  783.  
  784. #ifdef DF_STRUCTOK
  785.     R8dim im8dim;
  786. #endif /*DF_STRUCTOK*/
  787.  
  788.     /* find next rig */
  789.     if (foundRig) {        /* either RIGs present or don't know */
  790.     do {
  791.         DFerror = DFE_NOERROR;
  792.         if (Refset &&
  793.         DFIfind(dfile, DFTAG_RIG, Refset, 1,0,0, &dlep, &cdd)<0) {
  794.         /* try for RI8 and CI8s */
  795.         }
  796.             /* in next line, !ref is passed for isfirst.  If we have found
  797.            a ref before, ref is non-zero, hence isfirst is 0.  If
  798.            we have not found anything yet, ref is 0 and isfirst is 1 */
  799.         else if (!Refset && DFIfind(dfile, DFTAG_RIG, DFREF_WILDCARD,
  800.                     !Readrig.image.ref, Readrig.image.tag,
  801.                                         Readrig.image.ref, &dlep, &cdd) <0) {
  802.         if (foundRig==1) { /* RIGs present, but no more to return */
  803.             DFerror = DFE_NOMATCH;
  804.             return(-1);
  805.         }
  806.         foundRig = 0;    /* No RIGs present in file */
  807.         }
  808.         else {        /* RIG found */
  809.         if (DFR8getrig(dfile, dlep->dd[cdd].ref, &Readrig)<0) {
  810.             if (Refset || (DFerror != DFE_BADCALL)) {
  811.             Refset = 0;
  812.             return(-1);
  813.             }
  814.             Readrig.image.ref = dlep->dd[cdd].ref; /*to get next one */
  815.         } else { foundRig = 1; Refset = 0; }
  816.         }
  817.     } while (DFerror==DFE_BADCALL);
  818.     }
  819.     if (Refset || !foundRig) {    /* No RIGs present, look for RI8 and CI8 */
  820.     /* look for Refset if DFR8ref called, else look for next ref */
  821.         if ((Refset &&
  822.          (DFIfind(dfile, DFTAG_RI8, Refset, 1, 0, 0, &dlep, &cdd)==0)) ||
  823.         (!Refset &&
  824.          (DFIfind(dfile, DFTAG_RI8, DFREF_WILDCARD, !Readrig.image.ref,
  825.               Readrig.image.tag, Readrig.image.ref, &dlep, &cdd)==0)))
  826.             riref = dlep->dd[cdd].ref;
  827.  
  828.         if ((Refset &&
  829.          (DFIfind(dfile, DFTAG_CI8, Refset, 1, 0, 0, &dlep, &cdd)==0)) ||
  830.         (!Refset &&
  831.          (DFIfind(dfile, DFTAG_CI8, DFREF_WILDCARD, !Readrig.image.ref,
  832.               Readrig.image.tag, Readrig.image.ref, &dlep, &cdd)==0)))
  833.             ciref = dlep->dd[cdd].ref;
  834.  
  835.         Refset = 0;
  836.         if (!riref && !ciref) {
  837.             DFerror = DFE_NOMATCH;
  838.             return(-1);
  839.         }
  840.         if ((!ciref) || (riref && (riref<ciref))) { /* next image is RI8 */
  841.             Readrig.image.ref = riref;
  842.             Readrig.image.tag = DFTAG_RI8;
  843.         }
  844.         else {            /* next image is CI8 */
  845.             Readrig.image.ref = ciref;
  846.             Readrig.image.tag = DFTAG_CI8;
  847.             Readrig.descimage.compr.tag = DFTAG_RLE;
  848.         }
  849.  
  850. #ifdef DF_STRUCTOK        /* read in dimensions */
  851.         if (DFgetelement(dfile, DFTAG_ID8, Readrig.image.ref, &im8dim)>=0) {
  852.             Readrig.descimage.xdim = im8dim.xd;
  853.             Readrig.descimage.ydim = im8dim.yd;
  854.         }
  855. #else /*DF_STRUCTOK*/
  856.         if (DFgetelement(dfile, DFTAG_ID8, Readrig.image.ref, DFtbuf)>=0) {
  857.             register char *p;
  858.             p = DFtbuf;
  859.             UINT16READ(p, Readrig.descimage.xdim);
  860.             UINT16READ(p, Readrig.descimage.ydim);
  861.         }
  862. #endif /*DF_STRUCTOK*/
  863.         else return(-1);
  864.  
  865.         if (DFIfind(dfile, DFTAG_IP8, Readrig.image.ref, 1, 0, 0, &dlep,
  866.             &cdd)==0) {
  867.             Readrig.lut.tag = DFTAG_IP8;
  868.             Readrig.lut.ref = Readrig.image.ref;
  869.         }
  870.     }
  871.     Lastref = Readrig.image.ref; /* remember ref read */
  872.     return(0);
  873. }
  874.